fix(gjc): derive status from the native parent turn - #928

…ing holes

The typed herdrRpc overload now takes one method only (SingleHerdrMethod), so a
union like "pane.process_info" | "agent.get" no longer lets { target } through
as the union of both params. seam.test.ts pins that with ts-expect-error and
lists the two holes that still compile (an explicit result type, a plain-string
method) for the follow-up that splits the untyped fallback out.

conventions.test.ts gains HERDR_RPC_PENDING for server/gjc-status.ts (#928)
and server/index.ts (#859), whose open PRs add a pane.process_info call. The
docs, changelog fragment and comments no longer claim a target call cannot
compile, and "PR B" becomes the follow-up PR that drains the allowlist.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

…appers (#970)

## Problem

`server/herdr/client.ts` exported an untyped `herdrRpc(method: string,
params: Record<string, unknown>)`. Eleven server files called it
directly for four methods (`pane.process_info` x10, `agent.get` x6,
`pane.send_text` x2, `pane.send_keys` x1), each with its own inline
result type. Nothing stopped `{ target }` reaching `pane.process_info`,
which herdr then silently answers for the focused pane (the AGENTS.md
rule was prose only).

## Change

- `server/herdr/methods.ts`: `HerdrMethods`, a `{ [method]: { params;
result } }` map for those four methods. Params and result bodies come
from the generated schema types; `PaneProcessInfoParams`, `AgentTarget`
and `PaneProcessInfo` are now generator roots
(`scripts/generate-protocol-types.ts`, regenerated
`shared/herdr-api.generated.ts`). The map itself is hand-written because
herdr's schema links a method to its params (`request.oneOf`) but not to
its answer: answers are one `ResponseResult.oneOf` told apart only by a
`type` tag (`pane_process_info`, `agent_info`, `ok`).
- `herdrRpc<M extends keyof HerdrMethods>(method, params:
HerdrMethods[M]["params"], …): Promise<HerdrMethods[M]["result"]>` is
the first overload. An untyped fallback overload stays for methods the
map does not list yet. It refuses a typed method name
(`UntypedHerdrMethod<M>` is `never` for one), so
`herdrRpc("pane.process_info", { target })` is a compile error.
`server/herdr/seam.test.ts` pins that with `@ts-expect-error` and checks
the wire params of the new wrappers against a stand-in socket.
- New wrappers: `paneProcessInfo(paneId)` returns one shared
`ProcessInfo` (= generated `PaneProcessInfo`: shell_pid,
foreground_processes with pid/name/argv0/argv) and `agentGet(paneId)`
returns `AgentInfo`. The existing `paneSendText` / `paneSendKeys` now go
through the typed overload. The wrappers call the exported `herdrRpc`
binding, so tests that `spyOn(herdr, "herdrRpc")` keep working.
- Migrated (no open PR touches them): `server/pi.ts`, `server/omp.ts`,
`server/grok-store.ts`, `server/agy-store.ts`, `server/codex.ts` (x3).
Behaviour is unchanged: the same params go on the wire, with the same
default timeout and the same `.catch` / `try` at each call site.
`codex.ts` keeps its old `argv?: string[]` reading through a commented
cast, because the schema allows `argv: null` and that path has never
handled null. Changing that would change behaviour, so it is left for a
separate fix.
- Guard: `server/conventions.test.ts` ("herdr socket") now fails when
server code outside `server/herdr/` uses `herdrRpc`. The message names
the fix ("add a typed wrapper in server/herdr/client.ts; for pane status
use the server/collector.ts listeners") and the allowlist
`HERDR_RPC_ALLOWED`. A stale allowlist entry also fails. The
`events.subscribe` / `subscribeEvents` rules from #949 were already
there; their message now also says where `events.subscribe` lives.
- AGENTS.md: the `pane.process_info` line points at `paneProcessInfo` /
`HerdrMethods` and names the enforcing test. Only that one line changes;
#812, #888 and #894 also edit AGENTS.md.

## Allowlist (`HERDR_RPC_ALLOWED`, migrated in PR B)

| File | Open PRs touching it |
|------|----------------------|
| `server/conversation.ts` | #869 #912 #923 |
| `server/gjc-runtime.ts` | #912 |
| `server/hermes.ts` | #910 |
| `server/omo.ts` | #923 |
| `server/shell-agent.ts` | #885 #923 |

Built from `gh pr list --state open --limit 100 --json number,files` on
2026-10-14.

## Known limits (closed in PR B)

- The export is still named `herdrRpc`. Renaming it to `herdrRpcUnsafe`
would touch about 33 test files and 30 `scripts/` harnesses, several of
them in open PRs (api.contract, gjc.contract, omo.contract,
ui-regression, pending-input…). Tests and `scripts/` QA harnesses are
outside this guard's scope: they drive herdr (`pane.report_agent`,
`workspace.create`, …) and are not part of the bridge seam.
- A call with an explicit result type,
`herdrRpc<Inline>("pane.process_info", …)`, still reaches the untyped
fallback. That is the form the allowlisted files use, and they may not
change here. In server code the source guard closes this gap. The
fallback goes away once the allowlist is empty.

## Validation

- `bun run check fast`: green. A first run had one failure in
`server/portal.test.ts` ("does not treat an arbitrary interpreter as a
Portal script": the process argv read raced and returned undefined).
This change does not touch that file, it passed alone, and the rerun was
fully green.
- `bun run test:integration`: 455 pass, 0 fail, 14 skip in 38 files
(includes the omp, codex, codex-binding, pi, gjc, omo and hermes
contract tests).
- I checked by hand that the guard fails on a new `herdr.herdrRpc` use
in `server/pi.ts`.

## Follow-up: PR B

Once #869, #885, #910, #912 and #923 land: migrate the five allowlisted
files to `paneProcessInfo` / `agentGet` / `paneSendText` /
`paneSendKeys`, empty `HERDR_RPC_ALLOWED`, drop the untyped fallback
overload (or rename it `herdrRpcUnsafe` for tests and scripts), and
consider handling `argv: null` in `codex.ts`.

## Review

Fixed in 290d5f1:

- **Union of typed methods (medium, part of finding 1).** The typed
overload takes `SingleHerdrMethod<M>`, so `herdrRpc(cond ?
"pane.process_info" as const : "agent.get" as const, { target })` no
longer compiles. `seam.test.ts` pins this with a `@ts-expect-error`
line. Checked with tsc: the inferred `herdrRpc("pane.process_info", {
pane_id })` still returns the typed result.
- **Allowlist missed #928 and #859 (medium).** `conventions.test.ts`
adds `HERDR_RPC_PENDING` with `server/gjc-status.ts` (#928) and
`server/index.ts` (#859). Those PRs add a `pane.process_info` call, but
neither file calls herdrRpc on main yet, so the "no longer calls" check
skips them. It would be better for both PRs to switch to
`paneProcessInfo(paneId)`, which is a one-line change in each. After
that, these entries come out.
- **Docs claimed more than the PR delivers (low).** AGENTS.md now says
the guard enforces the rule, not the compiler, and that the allowlisted
and pending files still call herdrRpc. The changelog fragment now says
"no longer compiles without an explicit result type". "PR B" is replaced
with "a follow-up PR that moves these files to the wrappers once their
open PRs land". The fallback docblock in `client.ts` and the
`UntypedHerdrMethod` comment in `methods.ts` list the holes.

Deferred to the follow-up PR that drains `HERDR_RPC_ALLOWED`:

- **Explicit result type and widened string (rest of finding 1).**
`herdrRpc<T>("pane.process_info", { target })` and `herdrRpc(m as
string, { target })` still compile. With an explicit T, the fallback's
`M` stays at `string`, and that cannot be closed while the fallback
shares the name. Closing it means splitting the fallback out as
`herdrRpcUntyped` (or `herdrRpcUnsafe`) and moving about 400 test and
script call sites onto it. It also means converting the
`herdrRpc<T>("pane.process_info" | "agent.get", …)` calls in the five
allowlisted files, which conflicts with their open PRs. `seam.test.ts`
keeps both forms as compiling lines with a comment, so the follow-up can
turn them into `@ts-expect-error`.
- **Error message.** Two overloads are still present, so tsc reports a
bad inferred call such as `{ target }` to pane.process_info as `not
assignable to parameter of type 'never'` instead of naming the wrong
param. That message only gets better with the split.
- **Stale pending entries.** Nothing removes a `HERDR_RPC_PENDING` entry
on its own. If #928 or #859 switches to `paneProcessInfo` or closes, its
entry stays until someone takes it out by hand.
- **Tell the open PRs.** #912, #923, #928, #859 and #910 call
`herdrRpc<T>("pane.process_info", …)`. They should hear about the switch
to `paneProcessInfo` before the split lands. I have not commented on
those PRs.

Checks: `bun run check fast` passed (typecheck, build, 3452 unit tests).
`bun run test:integration` passed (455 pass, 0 fail).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

## Change

A custom Bun launcher can run the OMO engine normally while herdr
reports it as `pi` and its argv contains no standard OMO executable. The
chat lens then misses the native conversation.

Recognize custom runtimes from their OMO store and native holder
records, validating the live PID, process start and cwd. Keep each
holder's store/session identity through pending, malformed and ambiguous
transcript cases. Reuse the same identity in snapshot discovery, chat
routing and shell-start confirmation; verified OMO ownership takes
precedence over a child agent's label. Preserve standard and
hoisted-engine launch compatibility without matching custom filenames,
profiles or model names.

Custom recognition needs readable process metadata and a native holder
in an explicit OMO store or the default OMO store. Insufficient evidence
fails closed. This does not change launchers, model mappings or
authentication.

## Validation

- CI Bun 1.4.2: `bun run check fast` — generated types, both TypeScript
checks, production build, and unit suite pass (2,996 passed, 8 skipped).
- Isolated native contract: 10 tests, including custom/default stores,
pending sessions, negative identity, background logs and Codex/Devin/GJC
child labels.
- Real Chromium: six scenario groups covering store isolation, arbitrary
model metadata, legacy launch, no-evidence rejection, `/new`, live
first-message rendering and resume.
- Independent review reproductions for missing holder headers and
changed process cwd (including stale pane paths without process-level
cwd) are covered by focused regressions.

A running custom OMO pane was inspected read-only: the original PID
remained active, runtime detection succeeded, and the native transcript
parser returned its conversation. All reproduction inputs and browser
captures use isolated synthetic panes. No deployment or merge was
performed.

The related GJC status PR #928 was also checked in an isolated combined
worktree: native OMO ownership survives a raw GJC label at initial
snapshot and after periodic refresh.

---------

Co-authored-by: Hako <devswha@gmail.com>